from mcp.server.fastmcp import FastMCP, Context
import subprocess
import json
from typing import List, Optional

mcp = FastMCP("Codecov MCP Server")

"""
面向软件：codecov

所有 MCP tool 列表：
1. codecov_version - 获取 codecov 版本信息
   - 参数：无
   - 返回：统一 JSON 结构

2. codecov_upload - 使用 token 上传覆盖率数据
   - 参数：token (str) - 认证令牌
   - 返回：统一 JSON 结构

3. codecov_upload_files - 上传指定文件的覆盖率数据
   - 参数：files (List[str]) - 文件路径列表
   - 返回：统一 JSON 结构

4. codecov_upload_flags - 带 flags 标记的上传
   - 参数：flags (List[str]) - 标记列表
   - 返回：统一 JSON 结构

5. codecov_upload_env - 带环境变量的上传
   - 参数：env_vars (List[str]) - 环境变量列表（格式：key=value）
   - 返回：统一 JSON 结构

6. codecov_upload_required - 必需的上传操作
   - 参数：无
   - 返回：统一 JSON 结构

7. codecov_upload_named - 带命名的上传
   - 参数：name (str) - 上传名称
   - 返回：统一 JSON 结构

8. codecov_gcov_analysis - 使用 gcov 相关参数的分析
   - 参数：gcov_root (Optional[str]) - gcov 根目录，gcov_glob (Optional[List[str]]) - 文件匹配模式，gcov_exec (Optional[str]) - gcov 执行程序，no_gcov_out (bool) - 是否禁用 gcov 输出，gcov_args (Optional[str]) - gcov 参数
   - 返回：统一 JSON 结构

9. codecov_disable_features - 禁用特定功能的上传
   - 参数：disable (List[str]) - 要禁用的功能列表
   - 返回：统一 JSON 结构

10. codecov_upload_with_metadata - 带版本控制元数据的上传
    - 参数：root (Optional[str]) - 根目录，commit (Optional[str]) - 提交哈希，prefix (Optional[str]) - 前缀，branch (Optional[str]) - 分支，build (Optional[str]) - 构建号，pr (Optional[str]) - PR 编号，tag (Optional[str]) - 标签
    - 返回：统一 JSON 结构

所有工具返回统一 JSON 结构：
{
  "success": bool,
  "command": str,
  "exit_code": int,
  "stdout": str,
  "stderr": str
}
"""


@mcp.tool()
def codecov_version() -> dict:
    """
    获取 codecov 版本信息
    
    返回：
        JSON 结构包含命令执行结果
    """
    command = ["codecov", "--version"]
    result = subprocess.run(command, capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "command": " ".join(command),
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr
    }


@mcp.tool()
def codecov_upload(token: str) -> dict:
    """
    使用 token 上传覆盖率数据
    
    参数：
        token: 认证令牌
        
    返回：
        JSON 结构包含命令执行结果
    """
    command = ["codecov", "--token", token]
    result = subprocess.run(command, capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "command": " ".join(command),
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr
    }


@mcp.tool()
def codecov_upload_files(files: List[str]) -> dict:
    """
    上传指定文件的覆盖率数据
    
    参数：
        files: 文件路径列表
        
    返回：
        JSON 结构包含命令执行结果
    """
    command = ["codecov"]
    for file in files:
        command.extend(["--file", file])
    
    result = subprocess.run(command, capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "command": " ".join(command),
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr
    }


@mcp.tool()
def codecov_upload_flags(flags: List[str]) -> dict:
    """
    带 flags 标记的上传
    
    参数：
        flags: 标记列表
        
    返回：
        JSON 结构包含命令执行结果
    """
    command = ["codecov"]
    for flag in flags:
        command.extend(["--flags", flag])
    
    result = subprocess.run(command, capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "command": " ".join(command),
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr
    }


@mcp.tool()
def codecov_upload_env(env_vars: List[str]) -> dict:
    """
    带环境变量的上传
    
    参数：
        env_vars: 环境变量列表（格式：key=value）
        
    返回：
        JSON 结构包含命令执行结果
    """
    command = ["codecov"]
    for env_var in env_vars:
        command.extend(["--env", env_var])
    
    result = subprocess.run(command, capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "command": " ".join(command),
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr
    }


@mcp.tool()
def codecov_upload_required() -> dict:
    """
    必需的上传操作
    
    返回：
        JSON 结构包含命令执行结果
    """
    command = ["codecov", "--required"]
    result = subprocess.run(command, capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "command": " ".join(command),
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr
    }


@mcp.tool()
def codecov_upload_named(name: str) -> dict:
    """
    带命名的上传
    
    参数：
        name: 上传名称
        
    返回：
        JSON 结构包含命令执行结果
    """
    command = ["codecov", "--name", name]
    result = subprocess.run(command, capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "command": " ".join(command),
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr
    }


@mcp.tool()
def codecov_gcov_analysis(
    gcov_root: Optional[str] = None,
    gcov_glob: Optional[List[str]] = None,
    gcov_exec: Optional[str] = None,
    no_gcov_out: bool = False,
    gcov_args: Optional[str] = None
) -> dict:
    """
    使用 gcov 相关参数的分析
    
    参数：
        gcov_root: gcov 根目录
        gcov_glob: 文件匹配模式列表
        gcov_exec: gcov 执行程序
        no_gcov_out: 是否禁用 gcov 输出
        gcov_args: gcov 参数
        
    返回：
        JSON 结构包含命令执行结果
    """
    command = ["codecov"]
    
    if gcov_root:
        command.extend(["--gcov-root", gcov_root])
    
    if gcov_glob:
        for pattern in gcov_glob:
            command.extend(["--gcov-glob", pattern])
    
    if gcov_exec:
        command.extend(["--gcov-exec", gcov_exec])
    
    if no_gcov_out:
        command.append("--no-gcov-out")
    
    if gcov_args:
        command.extend(["--gcov-args", gcov_args])
    
    result = subprocess.run(command, capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "command": " ".join(command),
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr
    }


@mcp.tool()
def codecov_disable_features(disable: List[str]) -> dict:
    """
    禁用特定功能的上传
    
    参数：
        disable: 要禁用的功能列表
        
    返回：
        JSON 结构包含命令执行结果
    """
    command = ["codecov"]
    for feature in disable:
        command.extend(["--disable", feature])
    
    result = subprocess.run(command, capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "command": " ".join(command),
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr
    }


@mcp.tool()
def codecov_upload_with_metadata(
    root: Optional[str] = None,
    commit: Optional[str] = None,
    prefix: Optional[str] = None,
    branch: Optional[str] = None,
    build: Optional[str] = None,
    pr: Optional[str] = None,
    tag: Optional[str] = None
) -> dict:
    """
    带版本控制元数据的上传
    
    参数：
        root: 根目录
        commit: 提交哈希
        prefix: 前缀
        branch: 分支
        build: 构建号
        pr: PR 编号
        tag: 标签
        
    返回：
        JSON 结构包含命令执行结果
    """
    command = ["codecov"]
    
    if root:
        command.extend(["--root", root])
    
    if commit:
        command.extend(["--commit", commit])
    
    if prefix:
        command.extend(["--prefix", prefix])
    
    if branch:
        command.extend(["--branch", branch])
    
    if build:
        command.extend(["--build", build])
    
    if pr:
        command.extend(["--pr", pr])
    
    if tag:
        command.extend(["--tag", tag])
    
    result = subprocess.run(command, capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "command": " ".join(command),
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr
    }


if __name__ == "__main__":
    mcp.run()